home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / Docs / Vib2Dclap.list < prev    next >
Encoding:
Text File  |  1996-07-05  |  37.3 KB  |  781 lines  |  [TEXT/R*ch]
  1. /*   vibprocs.h
  2.  
  3.  
  4. List of vibrant procs folded into DClap library -- d.gilbert
  5.  
  6.  
  7. * ===========================================================================
  8. *
  9. *                            PUBLIC DOMAIN NOTICE
  10. *            National Center for Biotechnology Information (NCBI)
  11. *
  12. *  This software/database is a "United States Government Work" under the
  13. *  terms of the United States Copyright Act.  It was written as part of
  14. *  the author's official duties as a United States Government employee and
  15. *  thus cannot be copyrighted.  This software/database is freely available
  16. *  to the public for use. The National Library of Medicine and the U.S.
  17. *  Government do not place any restriction on its use or reproduction.
  18. *  We would, however, appreciate having the NCBI and the author cited in
  19. *  any work or product based on this material
  20. *
  21. *  Although all reasonable efforts have been taken to ensure the accuracy
  22. *  and reliability of the software and data, the NLM and the U.S.
  23. *  Government do not and cannot warrant the performance or results that
  24. *  may be obtained by using this software or data. The NLM and the U.S.
  25. *  Government disclaim all warranties, express or implied, including
  26. *  warranties of performance, merchantability or fitness for any particular
  27. *  purpose.
  28. *
  29. * ===========================================================================
  30. *
  31. * File Name:  vibprocs.h
  32. *
  33. * Author:  Jonathan Kans
  34. *
  35. * Version Creation Date:   7/1/91
  36. *
  37. * $Revision: 2.33 $
  38. *
  39. * File Description: 
  40. *       Vibrant procedure definitions
  41. *
  42. * Modifications:  
  43. * --------------------------------------------------------------------------
  44. * Date     Name        Description of modification
  45. * -------  ----------  -----------------------------------------------------
  46. *
  47. *
  48. * ==========================================================================
  49. */
  50.  
  51. #ifndef _VIBPROCS_
  52. #define _VIBPROCS_
  53.  
  54. #ifdef __cplusplus
  55. extern "C" {
  56. #endif
  57.  
  58. /***  GLOBAL VARIABLES  ***/
  59.  
  60. /*
  61. *  The fileDone flag indicates success or failure of the last
  62. *  file operation, and can be used to test for end-of-file on
  63. *  input.  The termCH character contains the character that
  64. *  terminated the most recently read string, field, or line.
  65. *  That character is not included in the string.
  66. */
  67.  
  68. extern  Nlm_Boolean  Nlm_fileDone;
  69. extern  Nlm_Int2     Nlm_fileError;
  70. extern  Nlm_Char     Nlm_termCH;
  71.  
  72. /*
  73. *  The currentKey variable can be used by callback routines to
  74. *  determine what key was most recently pressed by the user.
  75. */
  76.  
  77. //DUtil.h// extern  Nlm_Char  Nlm_currentKey;
  78.  
  79. /*
  80. *  The cmmdKey, ctrlKey, optKey and shftKey flags reflect the
  81. *  status of the command key, the control key, the option key,
  82. *  and the shift key of the keyboard, respectively.  Macintosh,
  83. *  IBM PC, and Unix machines may only have a subset of these
  84. *  modifier keys on their keyboards.  The dblClick flag is set
  85. *  if the user double clicked in a list selection box.
  86. */
  87.  
  88. //DUtil.h// extern  Nlm_Boolean  Nlm_cmmdKey;
  89. //DUtil.h// extern  Nlm_Boolean  Nlm_ctrlKey;
  90. //DUtil.h// extern  Nlm_Boolean  Nlm_optKey;
  91. //DUtil.h// extern  Nlm_Boolean  Nlm_shftKey;
  92. //DUtil.h// extern  Nlm_Boolean  Nlm_dblClick;
  93.  
  94. /*
  95. *  The screenRect contains the size in pixels of the computer screen.
  96. */
  97.  
  98. //DUtil.h// extern  Nlm_RecT  Nlm_screenRect;
  99.  
  100. /*
  101. *  Miscellaneous constants define the width and height of scroll bars.
  102. */
  103.  
  104. extern  Nlm_Int2  Nlm_hScrollBarHeight;
  105. extern  Nlm_Int2  Nlm_vScrollBarWidth;
  106.  
  107.  
  108. /*
  109. *  Miscellaneous constants define the height of certain control objects.
  110. */
  111.  
  112. extern  Nlm_Int2  Nlm_popupMenuHeight;
  113. extern  Nlm_Int2  Nlm_dialogTextHeight;
  114.  
  115. /***  PROCEDURES THAT CREATE INTERFACE OBJECTS  ***/
  116.  
  117. /***  WINDOW OBJECTS  ***/
  118.  
  119. /*
  120. *  When positive, the left and top window parameters specify the pixel
  121. *  location of the upper left hand corner of the window on the screen.
  122. *  When negative, they specify the a relative percentage position, with
  123. *  -50, -33 meaning centered horizontally and placed vertically one third
  124. *  of the way down the screen.  When positive, the width and height
  125. *  parameters indicate the pixel size of the window.  When negative, they
  126. *  indicate that the window, when first made visible, will size itself to
  127. *  fit around the objects it contains, with the absolute value of the
  128. *  width being the number of pixels to use as a border around the internal
  129. *  objects and the absolute value of the height being the spacing between
  130. *  objects.
  131. */
  132.  
  133. /*
  134. *  Document, Fixed, and Round windows may be dragged around the screen by
  135. *  the user.  Document windows may also be resized by the user.  When a
  136. *  Modal window is the front window, the user is prevented from bringing
  137. *  other windows to the front or from making menu choices.  This should
  138. *  be used only when extra information is essential in order to proceed,
  139. *  or to alert the user to critical error conditions.  Modal windows should
  140. *  be created when needed and destroyed immediately upon release.  If a
  141. *  modal window is hidden, it may inhibit any user input.  Floating windows
  142. *  float above other windows, and can be useful for selecting tools (such
  143. *  as in a MacPaint drawing palette) without needing to change the active
  144. *  window each time.  The close procedure is called when the user clicks in
  145. *  the close box of a window.  The callback procedure will usually hide or
  146. *  remove the window, or may display a modal window asking the user to
  147. *  confirm the close.  The activate and deactivate procedures are executed
  148. *  when a window is activated or deactivated, and the resize procedure is
  149. *  called when the user changes the size of a window.
  150. */
  151.  
  152. //DWindow.h// Nlm_WindoW  Nlm_DocumentWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close, Nlm_WndActnProc resize));
  153. //DWindow.h// Nlm_WindoW  Nlm_FixedWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  154. //DWindow.h// Nlm_WindoW  Nlm_FrozenWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  155. //DWindow.h// Nlm_WindoW  Nlm_RoundWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  156. //DWindow.h// Nlm_WindoW  Nlm_AlertWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  157. //DWindow.h// Nlm_WindoW  Nlm_ModalWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  158. //DWindow.h// Nlm_WindoW  Nlm_FloatingWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  159. //DWindow.h// Nlm_WindoW  Nlm_ShadowWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  160. //DWindow.h// Nlm_WindoW  Nlm_PlainWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  161.  
  162. //not-used?// void        Nlm_SetClose PROTO((Nlm_WindoW w, Nlm_WndActnProc cls));
  163. //not-used?// void        Nlm_SetActivate PROTO((Nlm_WindoW w, Nlm_WndActnProc act));
  164. //not-used?// void        Nlm_SetDeactivate PROTO((Nlm_WindoW w, Nlm_WndActnProc deact));
  165. //not-used?// void        Nlm_SetResize PROTO((Nlm_WindoW w, Nlm_WndActnProc resiz));
  166.  
  167. //not-used?// void        Nlm_SetWindowExtra PROTO((Nlm_WindoW w, Nlm_VoidPtr data, Nlm_WndFreeProc cleanup));
  168. //not-used?// Nlm_VoidPtr Nlm_GetWindowExtra PROTO((Nlm_WindoW w));
  169.  
  170. /***  GROUPING OBJECT  ***/
  171.  
  172. /*
  173. *  Groups are used for fine control of automatic positioning of objects
  174. *  within a window.  When containing radio buttons, the integer value of
  175. *  the group corresponds to the current button choice.  See SetValue and
  176. *  GetValue under Object Title and State Manipulations Procedures.  When
  177. *  both the width and height of a group are 0, objects within the group
  178. *  are overlapped at the same location.  The default group margins are
  179. *  3 horizontal and 2 vertical pixels.  This can be changed with the
  180. *  SetGroupMargins procedure.
  181. */
  182.  
  183. //DControl.h// Nlm_GrouP  Nlm_NormalGroup PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_GrpActnProc actn));
  184. //DControl.h// Nlm_GrouP  Nlm_HiddenGroup PROTO((Nlm_GrouP prnt,  Nlm_Int2 width, Nlm_Int2 height, Nlm_GrpActnProc actn));
  185. //DControl.h// void       Nlm_SetGroupMargins PROTO((Nlm_GrouP g, Nlm_Int2 xMargin, Nlm_Int2 yMargin));
  186. //DControl.h// void       Nlm_SetGroupSpacing PROTO((Nlm_GrouP g, Nlm_Int2 xSpacing, Nlm_Int2 ySpacing));
  187.  
  188. /*
  189. *  In the following object creation procedures, whenever the parent
  190. *  parameter specifies GrouP, a WindoW may also be used, because
  191. *  both objects are handles to the same dummy structure.
  192. */
  193.  
  194. /***  CONTROL OBJECTS  ***/
  195.  
  196. /***  Button Objects  ***/
  197.  
  198. /*
  199. *  Push buttons and Default buttons allow the user to trigger specific
  200. *  callback functions.  Check boxes allow the user to specify boolean
  201. *  yes/no flags.  The parent group containing radio buttons has an
  202. *  integer value that corresponds to one of several mutually exclusive
  203. *  choices that the user can make.  Radio buttons return handles only to
  204. *  allow them to be individually disabled or hidden.  They should be used
  205. *  in the same manner as list items and choice items.
  206. */
  207.  
  208. //DControl.h// Nlm_ButtoN  Nlm_PushButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  209. //DControl.h// Nlm_ButtoN  Nlm_DefaultButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  210. //DControl.h// Nlm_ButtoN  Nlm_CheckBox PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  211. //DControl.h// Nlm_ButtoN  Nlm_RadioButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title));
  212.  
  213. /***  Scrolling Choice List Objects  ***/
  214.  
  215. /*
  216. *  Single choice and Multiple choice lists functionally correspond to groups of
  217. *  radio buttons or check boxes.  Because they have the appearance of scrolling
  218. *  choice lists instead of buttons, additional items do not change the size of
  219. *  the list object.  To prevent automatic refreshing of the screen after every
  220. *  append use the Disable function.  Calling Enable will update the list.
  221. */
  222.  
  223. //DControl.h// Nlm_LisT  Nlm_SingleList PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_LstActnProc actn));
  224. //DControl.h// Nlm_LisT  Nlm_MultiList PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_LstActnProc actn));
  225. //DControl.h// void      Nlm_ListItem PROTO((Nlm_LisT l, Nlm_CharPtr title));
  226.  
  227. /***  Menu Objects  ***/
  228.  
  229. /*
  230. *  A Pulldown or Apple menu can appear on the desktop (NULL window) or
  231. *  in a menu bar within a given window.  Popup menus can appear anywhere
  232. *  in a window.  Submenus can appear in any of the above menus, or in
  233. *  other submenus.  Command items act exactly like push buttons, in that
  234. *  they are used to trigger specific callback routines.  Status items
  235. *  correspond to boolean check boxes.  Choice groups are mutually
  236. *  exclusive groups of choices that function exactly like radio groups or
  237. *  single choice lists.  The active choice has a check mark in front of
  238. *  it.  A Popup list is a popup menu with a choice group that displays the
  239. *  current value of the choice group on the window.  The DeskAccGroup
  240. *  allows the user to display a Macintosh desk accessory menu (usually in
  241. *  the Apple menu).  A Font group creates a menu choice group composed of
  242. *  the available fonts in the System file.  The Separator item places a
  243. *  dotted line in between groups of menu items.
  244. */
  245.  
  246.  
  247. //DMenu.h// Nlm_MenU    Nlm_PulldownMenu PROTO((Nlm_WindoW w, Nlm_CharPtr title));
  248. //DMenu.h// Nlm_MenU    Nlm_AppleMenu PROTO((Nlm_WindoW w));
  249. //DMenu.h// Nlm_MenU    Nlm_PopupMenu PROTO((Nlm_GrouP prnt, Nlm_CharPtr title));
  250. //DMenu.h// Nlm_MenU    Nlm_SubMenu PROTO((Nlm_MenU m, Nlm_CharPtr title));
  251. //DMenu.h// Nlm_IteM    Nlm_CommandItem PROTO((Nlm_MenU m, Nlm_CharPtr title, Nlm_ItmActnProc actn));
  252. //DMenu.h// Nlm_IteM    Nlm_StatusItem PROTO((Nlm_MenU m, Nlm_CharPtr title, Nlm_ItmActnProc actn));
  253. //DMenu.h// Nlm_ChoicE  Nlm_ChoiceGroup PROTO((Nlm_MenU m, Nlm_ChsActnProc actn));
  254. //DMenu.h// Nlm_IteM    Nlm_ChoiceItem PROTO((Nlm_ChoicE c, Nlm_CharPtr title));
  255. //DMenu.h// Nlm_PopuP   Nlm_PopupList PROTO((Nlm_GrouP prnt, Nlm_Boolean macLike, Nlm_PupActnProc actn));
  256. //DMenu.h// void        Nlm_PopupItem PROTO((Nlm_PopuP p, Nlm_CharPtr title));
  257. //DMenu.h// void        Nlm_DeskAccGroup PROTO((Nlm_MenU m));
  258. //DMenu.h// Nlm_ChoicE  Nlm_FontGroup PROTO((Nlm_MenU m));
  259. //DMenu.h// void        Nlm_SeparatorItem PROTO((Nlm_MenU m));
  260.  
  261. /***  Bar Object  ***/
  262.  
  263. /*
  264. *  This scroll bar is a normal object that can be used for input of integers.
  265. *  Width or height specify the number of standard character widths or standard
  266. *  character line heights to make the scroll bar.  CorrectBarValue will change
  267. *  the scroll bar value without triggering the scroll bar's callback.
  268. */
  269.  
  270. //DControl.h// Nlm_BaR  Nlm_ScrollBar PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_BarScrlProc actn));
  271. //DControl.h// void     Nlm_CorrectBarValue PROTO((Nlm_BaR b, Nlm_Int2 val));
  272. //DControl.h// void     Nlm_CorrectBarMax PROTO((Nlm_BaR b, Nlm_Int2 max));
  273. //DControl.h// void     Nlm_CorrectBarPage PROTO((Nlm_BaR b, Nlm_Int2 pgUp, Nlm_Int2 pgDn));
  274.  
  275. /***  Repeat Object  ***/
  276.  
  277. /*
  278. *  Repeat buttons are implemented as autonomous PaneLs.  They will repeatedly
  279. *  trigger the callback in response to click and hold messages.
  280. */
  281.  
  282. //DControl.h// Nlm_RepeaT  Nlm_RepeatButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_RptClckProc actn));
  283.  
  284. /***  Icon Object  ***/
  285.  
  286. /*
  287. *  Icon buttons are implemented as autonomous PaneLs.  They are used for to display
  288. *  arbitrary bitmaps.  The draw callback should get the value of the icon button to
  289. *  determine what to display.  The click, drag, hold and release mouse callbacks (see
  290. *  SetPanelClick) may set the value of the icon button to change its appearance.
  291. */
  292.  
  293. //DControl.h// Nlm_IcoN    Nlm_IconButton PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_IcnActnProc draw, Nlm_IcnChngProc inval,
  294.                 Nlm_IcnClckProc click, Nlm_IcnClckProc drag, Nlm_IcnClckProc hold, Nlm_IcnClckProc release));
  295.  
  296. /***  Switch Object  ***/
  297.  
  298. /*
  299. *  The switch object is used as a miniature scroll bar, with up and down arrows but no
  300. *  thumb or page areas.  It can optionally display a (non-editable) text representation
  301. *  of the value (e.g., "5/15").  The value is manipulated with SetValue and GetValue.
  302. *  The arrows will allow the user to set values from 1 through max.  SetSwitchParams will
  303. *  set both the max and the value at once, to avoid flickering by multiple redraws.
  304. */
  305.  
  306. //DControl.h// Nlm_SwitcH  Nlm_UpDownSwitch PROTO((Nlm_GrouP prnt, Nlm_Boolean text, Nlm_SwtChngProc actn));
  307. //DControl.h// Nlm_SwitcH  Nlm_LeftRightSwitch PROTO((Nlm_GrouP prnt, Nlm_Boolean text, Nlm_SwtChngProc actn));
  308. //DControl.h// void        Nlm_SetSwitchMax PROTO((Nlm_SwitcH s, Nlm_Int2 max));
  309. //DControl.h// Nlm_Int2    Nlm_GetSwitchMax PROTO((Nlm_SwitcH s));
  310. //DControl.h// void        Nlm_SetSwitchParams PROTO((Nlm_SwitcH s, Nlm_Int2 value, Nlm_Int2 max));
  311.  
  312. /***  TEXT OBJECTS  ***/
  313.  
  314. /***  Editable Text Objects  ***/
  315.  
  316. /*
  317. *  A Dialog text item contains a single line of text, and pressing the
  318. *  tab key will step between individual dialog text items in the front
  319. *  window.  A Scroll text box can hold multiple lines of text.
  320. */
  321.  
  322. //DDialogText.h// Nlm_TexT  Nlm_DialogText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn));
  323. //DDialogText.h// Nlm_TexT  Nlm_HiddenText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn, Nlm_TxtActnProc tabProc));
  324. //DDialogText.h// Nlm_TexT  Nlm_PasswordText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn));
  325. //DDialogText.h// Nlm_TexT  Nlm_ScrollText PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_FonT font, Nlm_Boolean wrap, Nlm_TxtActnProc actn));
  326.  
  327. //DDialogText.h// void      Nlm_SetTextSelect PROTO((Nlm_TexT t, Nlm_TxtActnProc slct, Nlm_TxtActnProc dslct));
  328.  
  329. //DDialogText.h// Nlm_TexT  Nlm_CurrentText PROTO((void));
  330. //DDialogText.h// void      Nlm_TextSelectionRange PROTO((Nlm_TexT t, Nlm_Int2Ptr begin, Nlm_Int2Ptr end));
  331.  
  332. //DDialogText.h// void      Nlm_CutText PROTO((Nlm_TexT t));
  333. //DDialogText.h// void      Nlm_CopyText PROTO((Nlm_TexT t));
  334. //DDialogText.h// void      Nlm_PasteText PROTO((Nlm_TexT t));
  335. //DDialogText.h// void      Nlm_ClearText PROTO((Nlm_TexT t));
  336.  
  337. //DDialogText.h// size_t    Nlm_TextLength PROTO((Nlm_TexT t));
  338. //DDialogText.h// void      Nlm_SelectText PROTO((Nlm_TexT t, Nlm_Int2 begin, Nlm_Int2 end));
  339.  
  340. /***  Static Prompt Objects  ***/
  341.  
  342. /*
  343. *  The static prompt is not editable, but is used to display status
  344. *  information or instructions to the user.
  345. */
  346.  
  347. //DDialogText.h// Nlm_PrompT  Nlm_StaticPrompt  PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_FonT font, Nlm_Char just));
  348.  
  349. /***  Display Object  ***/
  350.  
  351. /*
  352. *  The currently selected display object in the front window receives
  353. *  the output that is sent to the terminal file.
  354.     // Nlm_DisplaY is a form of Nlm_SlatE (see below)
  355. */
  356.  
  357. //DPanel.h// Nlm_DisplaY  Nlm_NormalDisplay PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  358.  
  359. //DPanel.h// Nlm_DisplaY  Nlm_ScrollDisplay PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  360.  
  361. /***  SIMPLE UNIVERSAL DRAWING OBJECT  ***/
  362.  
  363. /*
  364. *  A panel object is a rectangular box on a window that provides a universal
  365. *  drawing environment. Panels translate click actions and drawing requests
  366. *  to instance-specific procedures.  The SimplePanel and AutonomousPanel objects
  367. *  are autonomous in that they create a single object within a window or group.
  368. *  (The more general and complex slate/panel combinations are discussed in the
  369. *  next section.)  SetPanelClick assigns click, drag, hold and release callbacks
  370. *  to a given panel.  SimplePanels have only the minimum parameters to specify a
  371. *  panel, and it is expected that the specific application callbacks for click,
  372. *  draw, etc., will handle the entire behavior of the panel.
  373. *
  374. *  AutonomousPanels allow the creation of higher-level graphical objects that
  375. *  can function like built-in Vibrant control objects while allowing much fancier
  376. *  graphical display and manipulation.  The extra parameter specifies the number
  377. *  of extra bytes to be placed on top of the panel instance data, and the data
  378. *  can be accessed with SetPanelExtra and GetPanelExtra.  The reset callback is
  379. *  called via the Reset class function, and should be used to free any instance-
  380. *  specific allocated memory that may be pointed to in the extra data.  In order
  381. *  to override certain class functions (e.g., to allow SetTitle to apply to a
  382. *  particular autonomous panel), the classPtr function can point to a GphPrcs
  383. *  array (in static or heap memory).  Any function pointer that is not NULL will
  384. *  override the standard function.
  385. *
  386. *  The purpose of providing separate slates and panels (see next section) is to
  387. *  allow multiple independent panels to be placed in the same scrolling unit.
  388. *  The slate handles scrolling, and the individual panel children have their
  389. *  own click and draw callbacks.  Slates are distinguished internally from
  390. *  autonomous panels because their click through reset procedures are all NULL.
  391. */
  392.  
  393. //DPanel.h// Nlm_PaneL  Nlm_SimplePanel PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_PnlActnProc draw));
  394.  
  395. //DPanel.h// Nlm_PaneL  Nlm_AutonomousPanel PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_PnlActnProc draw, Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl, Nlm_Int2 extra, Nlm_PnlActnProc reset, Nlm_GphPrcsPtr classPtr));
  396.  
  397. //DPanel.h// void       Nlm_SetPanelClick PROTO((Nlm_PaneL p, Nlm_PnlClckProc click, Nlm_PnlClckProc drag, Nlm_PnlClckProc hold, Nlm_PnlClckProc release));
  398.  
  399. //not-used// void       Nlm_SetPanelExtra PROTO((Nlm_PaneL p, Nlm_VoidPtr sptr));
  400. //not-used// void       Nlm_GetPanelExtra PROTO((Nlm_PaneL p, Nlm_VoidPtr sptr));
  401.  
  402. /***  GENERALIZED SCROLLABLE DRAWING OBJECT  ***/
  403.  
  404. /*
  405. *  A slate object is a rectangular box on a window that provides a universal
  406. *  drawing environment to its panel object children. Panels translate click
  407. *  actions and drawing requests to instance-specific procedures.  The parent
  408. *  slate must be notified of individual row and column pixel offsets, and of
  409. *  the corresponding row heights and column widths, in order for slate scroll
  410. *  bars to work automatically.  The panel must be notified of the actual size
  411. *  of its virtual rectangle.  The panel instance procedures should use the
  412. *  GetOffset procedure to determine the pixel offset for purposes of drawing
  413. *  and responding to clicks.  The VirtualSlate procedure allows specification
  414. *  of virtual scroll positions before and after the real scroll positions in
  415. *  a slate.  When the user drags the scroll bar thumb into a virtual area, the
  416. *  virtual action callback should be used to load new data into the slate.
  417. *  The GeneralSlate allows the specification of an alternative scroll bar
  418. *  callback procedure for a scrolling slate, as well as extra instance space
  419. *  and an overriding class function, in order to effectively have an autonomous
  420. *  scrolling panel.  The default scroll bar procedure should be sufficient
  421. *  for most situations.  Superimposed panels, or derivatives of panels, can be
  422. *  used to build complicated behaviors using simpler objects.
  423. */
  424.  
  425. //DPanel.h// Nlm_SlatE  Nlm_ScrollSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  426. //DPanel.h// Nlm_SlatE  Nlm_NormalSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  427. //DPanel.h// Nlm_SlatE  Nlm_HiddenSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  428. //DPanel.h// Nlm_SlatE  Nlm_GeneralSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_SltScrlProc scrl, Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr));
  429. //DPanel.h// void       Nlm_VirtualSlate PROTO((Nlm_SlatE s, Nlm_Int2 before, Nlm_Int2 after, Nlm_SltScrlProc actn));
  430.  
  431. //DPanel.h// void       Nlm_RegisterRow PROTO((Nlm_SlatE s, Nlm_Int2 position, Nlm_Int2 height, Nlm_Int2 count));
  432. //DPanel.h// void       Nlm_RegisterColumn PROTO((Nlm_SlatE s, Nlm_Int2 position, Nlm_Int2 width, Nlm_Int2 count));
  433.  
  434. //DPanel.h// Nlm_BaR    Nlm_GetSlateVScrollBar PROTO((Nlm_SlatE s));
  435. //DPanel.h// Nlm_BaR    Nlm_GetSlateHScrollBar PROTO((Nlm_SlatE s));
  436.  
  437. //DPanel.h// Nlm_PaneL  Nlm_CustomPanel PROTO((Nlm_SlatE s, Nlm_PnlActnProc draw, Nlm_Int2 extra, Nlm_PnlActnProc reset));
  438. //not-used?// Nlm_PaneL  Nlm_GeneralPanel PROTO((Nlm_SlatE s, Nlm_PnlActnProc draw, Nlm_Int2 extra, Nlm_PnlActnProc reset, Nlm_GphPrcsPtr classPtr));
  439.  
  440. //DPanel.h// void       Nlm_RegisterRect PROTO((Nlm_PaneL p, Nlm_RectPtr r));
  441.  
  442. //DPanel.h// void       Nlm_SetSlateChar PROTO((Nlm_SlatE s, Nlm_SltCharProc chr));
  443. //DPanel.h// void       Nlm_CaptureSlateFocus  PROTO((Nlm_SlatE s));
  444.  
  445. /***  APPLICATION CHARACTER PROCEDURE  ***/
  446.  
  447. /*
  448. *  The KeyboardView procedure specifies an application procedure to be
  449. *  called whenever the user presses a key on the keyboard, regardless of
  450. *  other action to be taken in response to that event.
  451. */
  452.  
  453. void  Nlm_KeyboardView PROTO((Nlm_KeyProc key));
  454.  
  455. /***  PRINTING PROCEDURES  ***/
  456.  
  457. //DUtil.h// Nlm_WindoW   Nlm_StartPrinting PROTO((void));
  458. //DUtil.h// void         Nlm_EndPrinting PROTO((Nlm_WindoW w));
  459.  
  460. //DUtil.h// Nlm_Boolean  Nlm_StartPage PROTO((void));
  461. //DUtil.h// Nlm_Boolean  Nlm_EndPage PROTO((void));
  462.  
  463. //DUtil.h// Nlm_Boolean  Nlm_PrintingRect PROTO((Nlm_RectPtr rpt));
  464.  
  465. /***  FILE SPECIFICATION PROCEDURES  ***/
  466.  
  467. //DUtil.h// Nlm_Boolean  Nlm_GetInputFileName PROTO((Nlm_CharPtr fileName, size_t maxsize, Nlm_CharPtr extType, Nlm_CharPtr macType));
  468. //DUtil.h// Nlm_Boolean  Nlm_GetOutputFileName PROTO((Nlm_CharPtr fileName, size_t maxsize, Nlm_CharPtr dfault));
  469.  
  470. /***  APPLICATION TIMER PROCEDURE  ***/
  471.  
  472. /*
  473. *  The Metronome procedure specifies an application procedure to be called
  474. *  18 or 20 times per second (on the PC and the Macintosh, respectively)
  475. *  regardless of any action by the user.
  476. */
  477.  
  478. void  Nlm_Metronome PROTO((Nlm_VoidProc actn));
  479.  
  480. /***  MAIN EVENT LOOP PROCEDURE  ***/
  481.  
  482. /*
  483. *  After creating all menus, windows, and window objects, the Nlm_Main
  484. *  procedure should call ProcessEvents.  ProcessEvents will convert all
  485. *  toolbox events or messages into calls to the appropriate object.
  486. */
  487.  
  488. //not-used// void  Nlm_ProcessEvents PROTO((void));
  489.  
  490. /***  QUIT PROGRAM PROCEDURE  ***/
  491.  
  492. /*
  493. *  When a callback function determines that the program is finished it
  494. *  should call QuitProgram.  This will allow the ProcessEvents loop to
  495. *  be exited.
  496. */
  497.  
  498. //DApplication.h// void  Nlm_QuitProgram PROTO((void));
  499.  
  500. /***  PROCEDURES THAT ATTACH CALLBACKS TO INTERFACE OBJECTS  ***/
  501.  
  502. /*
  503. *  Given a handle to an object, these procedures will set callback
  504. *  functions for various kinds of events.  The action procedure is
  505. *  executed whenever the user does something like clicking the mouse
  506. *  button on an object and then releasing the mouse button while
  507. *  the mouse is still over the object.  The item parameter is 0 to
  508. *  refer to a parent or individual object, and is >0 to refer to a
  509. *  particular child of a group object.  Although only some of the
  510. *  above procedures take an action as an explicit parameter, every
  511. *  graphic object has an action procedure field, which can be set
  512. *  or reset as desired.
  513. */
  514.  
  515. void  Nlm_SetAction PROTO((Nlm_Handle a, Nlm_ActnProc actn));
  516.  
  517. /***  PROCEDURES THAT MODIFY INTERFACE OBJECTS  ***/
  518.  
  519. /***  Object Position and Appearance Procedures  ***/
  520.  
  521. /*
  522. *  When an object is added to a window or group, it is placed at the
  523. *  next available location.  The parent then records the size and
  524. *  position of the object and recalculates the next available location.
  525. *  Advance will place the next object to the right of the previous one
  526. *  (normally it would be placed below the previous object).  Break will
  527. *  place the next object at the left margin underneath all previously
  528. *  defined objects, and will reset the top margin so that Advance will
  529. *  work properly.  SetNextPosition and GetNextPosition give programs
  530. *  finer control over object positioning, including the ability to
  531. *  overlap objects.  Creating a group with width and height equal to 0
  532. *  will also result in overlapped objects.
  533. */
  534.  
  535. //DView.h// void  Nlm_Advance PROTO((Nlm_Handle a));
  536. //DView.h// void  Nlm_Break PROTO((Nlm_Handle a));
  537.  
  538. //DView.h// void  Nlm_SetNextPosition PROTO((Nlm_Handle a, Nlm_PoinT nps));
  539. //DView.h// void  Nlm_GetNextPosition PROTO((Nlm_Handle a, Nlm_PointPtr nps));
  540.  
  541. /***  Item Count Procedure  ***/
  542.  
  543. /*
  544. *  CountItems returns the number of items in a parent object.
  545. */
  546.  
  547. //DView.h// Nlm_Int2  Nlm_CountItems PROTO((Nlm_Handle a));
  548.  
  549. /***  Object Visibility and Responsiveness Procedures  ***/
  550.  
  551. /*
  552. *  Show makes any object visible (unless, for example, the parent of the
  553. *  object happens to be invisible).  All objects except windows are shown
  554. *  when they are created.  Hide will make any object invisible.  Enable
  555. *  and Disable change the responsiveness of an object to mouse clicks and
  556. *  key presses.  All objects are enabled when created.  Select is used to
  557. *  bring windows to the front, to select a dialog text item, or to select
  558. *  a particular display object for use as a console terminal display.
  559. */
  560.  
  561. //DView.h// Nlm_Boolean  Nlm_Enabled PROTO((Nlm_Handle a));
  562. //DView.h// Nlm_Boolean  Nlm_Visible PROTO((Nlm_Handle a));
  563. //DView.h// void         Nlm_ObjectRect PROTO((Nlm_Handle a, Nlm_RectPtr r));
  564. //DView.h// void         Nlm_InvalObject PROTO((Nlm_Handle a));
  565.  
  566. //DView.h// void         Nlm_Show PROTO((Nlm_Handle a));
  567. //DView.h// void         Nlm_Hide PROTO((Nlm_Handle a));
  568. //DView.h// void         Nlm_Enable PROTO((Nlm_Handle a));
  569. //DView.h// void         Nlm_Disable PROTO((Nlm_Handle a));
  570. //DView.h// void         Nlm_Select PROTO((Nlm_Handle a));
  571.  
  572. /***  Object Title and State Manipulation Procedures  ***/
  573.  
  574. /*
  575. *  The status of an object is polled with one of the following procedures.
  576. *  Title refers to the title or prompt of an object.  Three kinds of values
  577. *  are recognized:  Groups of radio buttons, single choice lists, and menu
  578. *  choice groups have elements that are mutually exclusive, and thus have a
  579. *  single integer as their value.  The SetValue and GetValue procedures are
  580. *  appropriate for these objects.  Boolean objects (check boxes, status items)
  581. *  use SetStatus and GetStatus.  GetNextItem will find the first set Boolean
  582. *  item after prev, and will return 0 if there are no more set items.  Text
  583. *  objects use SetTitle and GetTitle.  SetOffset and GetOffset will manipulate
  584. *  the scroll bar offsets for any object.  SetPosition and GetPosition
  585. *  manipulate the position of an object.  SetRange is used to set the page
  586. *  increment and maximum values for a scroll bar.  Reset will clear the value
  587. *  of an object or remove all children from a group.
  588. */
  589.  
  590. //DView.h// void         Nlm_SetTitle PROTO((Nlm_Handle a, Nlm_CharPtr title));
  591. //DView.h// void         Nlm_GetTitle PROTO((Nlm_Handle a, Nlm_CharPtr title, size_t maxsize));
  592. //DView.h// void         Nlm_SetValue PROTO((Nlm_Handle a, Nlm_Int2 value));
  593. //DView.h// Nlm_Int2     Nlm_GetValue PROTO((Nlm_Handle a));
  594. //DView.h// void         Nlm_SetStatus PROTO((Nlm_Handle a, Nlm_Boolean status));
  595. //DView.h// Nlm_Boolean  Nlm_GetStatus PROTO((Nlm_Handle a));
  596. //DView.h// void         Nlm_SetOffset PROTO((Nlm_Handle a, Nlm_Int2 horiz, Nlm_Int2 vert));
  597. //DView.h// void         Nlm_GetOffset PROTO((Nlm_Handle a, Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert));
  598. //DView.h// void         Nlm_SetPosition PROTO((Nlm_Handle a, Nlm_RectPtr r));
  599. //DView.h// void         Nlm_GetPosition PROTO((Nlm_Handle a, Nlm_RectPtr r));
  600. //DView.h// void         Nlm_SetRange PROTO((Nlm_Handle a, Nlm_Int2 pgUp, Nlm_Int2 pgDn, Nlm_Int2 max));
  601.  
  602. //DView.h// void         Nlm_SetItemTitle PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_CharPtr title));
  603. //DView.h// void         Nlm_GetItemTitle PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_CharPtr title, size_t maxsize));
  604. //DView.h// void         Nlm_SetItemStatus PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_Boolean status));
  605. //DView.h// Nlm_Boolean  Nlm_GetItemStatus PROTO((Nlm_Handle a, Nlm_Int2 item));
  606.  
  607. //DView.h// Nlm_Int2     Nlm_GetNextItem PROTO((Nlm_Handle a, Nlm_Int2 prev));
  608.  
  609. //DView.h// void         Nlm_Reset PROTO((Nlm_Handle a));
  610.  
  611. /***  Object Destruction Procedure  ***/
  612.  
  613. /*
  614. *  Remove hides an object and then completely disposes of all memory structures
  615. *  associated with that object.
  616. */
  617.  
  618. //DView.h// Nlm_Handle  Nlm_Remove PROTO((Nlm_Handle a));
  619.  
  620. /***  MISCELLANEOUS WINDOW AND OBJECT PROCEDURES  ***/
  621.  
  622. //DView.h// Nlm_Handle   Nlm_Parent PROTO((Nlm_Handle a));
  623.  
  624. //DWindow.h// void         Nlm_RealizeWindow PROTO((Nlm_WindoW w));
  625. //DWindow.h// Nlm_WindoW   Nlm_WhichWindow PROTO((Nlm_PoinT mouseLoc));
  626. //DWindow.h// Nlm_Boolean  Nlm_InWindow PROTO((Nlm_PoinT mouseLoc));
  627. //DWindow.h// Nlm_WindoW   Nlm_FrontWindow PROTO((void));
  628. //DWindow.h// Nlm_Boolean  Nlm_InFront PROTO((Nlm_WindoW w));
  629. //DWindow.h// void         Nlm_UseWindow PROTO((Nlm_WindoW w));
  630. //DWindow.h// Nlm_WindoW   Nlm_CurrentWindow PROTO((void));
  631. //DWindow.h// Nlm_Boolean  Nlm_UsingWindow PROTO((Nlm_WindoW w));
  632. //DWindow.h// Nlm_WindoW   Nlm_ActiveWindow PROTO((void));
  633. //DWindow.h// void         Nlm_EraseWindow PROTO((Nlm_WindoW w));
  634. //DView.h// Nlm_WindoW   Nlm_ParentWindow PROTO((Nlm_Handle a));
  635. //DWindow.h// Nlm_WindoW   Nlm_SavePort PROTO((Nlm_Handle a));
  636. //DWindow.h// void         Nlm_RestorePort PROTO((Nlm_WindoW w));
  637. //DWindow.h// void         Nlm_Update PROTO((void));
  638. //DUtil.h// Nlm_Boolean  Nlm_EventAvail PROTO((void));
  639. //DUtil.h// void         Nlm_FlushEvents PROTO((void));
  640. //not-used// void         Nlm_ProcessAnEvent PROTO((void));
  641. //DApplication.h// void         Nlm_ProcessEventOrIdle PROTO((void));
  642. //not-used// void         Nlm_ProcessExternalEvent PROTO((void));
  643. //DView.h// Nlm_Boolean  Nlm_AllParentsEnabled PROTO((Nlm_Handle a));
  644. //DView.h// Nlm_Boolean  Nlm_AllParentsVisible PROTO((Nlm_Handle a));
  645. //DApplication.h//void         Nlm_RemoveDyingWindows PROTO((void));
  646. //not-used// void         Nlm_UnloadSegment PROTO((Nlm_VoidProc routineAddr));
  647. //not-used??function is undocumented// void         Nlm_SetBarAnomaly PROTO((Nlm_BaR b, Nlm_Boolean anomaly));
  648.  
  649. /***  OBJECT ALIGNMENT PROCEDURE FOR USE WITHOUT GROUP REPOSITIONING  ***/
  650.  
  651. #ifdef WIN_MAC
  652. #define Nlm_HANDLE Nlm_Handle
  653. #endif
  654. #ifdef WIN_MSWIN
  655. #define Nlm_HANDLE int
  656. #endif
  657. #ifdef WIN_MOTIF
  658. #define Nlm_HANDLE Nlm_Handle
  659. #endif
  660.  
  661. #define ALIGN_LEFT      1
  662. #define ALIGN_RIGHT     2
  663. #define ALIGN_CENTER    3
  664. #define ALIGN_JUSTIFY   4
  665. #define ALIGN_UPPER     5
  666. #define ALIGN_LOWER     6
  667. #define ALIGN_MIDDLE    7
  668. #define ALIGN_VERTICAL  8
  669.  
  670. void CDECL   Nlm_AlignObjects VPROTO((int align, ...));
  671.  
  672. /***  FILE HANDLING PROCEDURES  ***/
  673.  
  674. /*
  675. *  Files do not use the same procedures as other kinds of (visual) objects, and
  676. *  have separate procedures for creation, manipulation, and destruction.  The
  677. *  fileDone flag is set if the file was successfully opened.  The fileDone flag
  678. *  also indicates whether a read or write statement was successful, and can be
  679. *  used to determine if the end of a file was detected by a read statement.
  680. */
  681.  
  682. void         Nlm_ReadText PROTO((FILE *f, Nlm_CharPtr str, size_t maxsize));
  683. void CDECL   Nlm_WriteText VPROTO((FILE *f, char *format, ...));
  684. void CDECL   Nlm_WriteLog VPROTO((char *format, ...));
  685.  
  686. Nlm_Char     Nlm_ReadChar PROTO((FILE *f));
  687. void         Nlm_ReadString PROTO((FILE *f, Nlm_CharPtr str, size_t maxsize));
  688. void         Nlm_ReadField PROTO((FILE *f, Nlm_CharPtr str, size_t maxsize));
  689. void         Nlm_ReadLine PROTO((FILE *f, Nlm_CharPtr str, size_t maxsize));
  690. Nlm_Uint2    Nlm_ReadCard PROTO((FILE *f));
  691. Nlm_Int2     Nlm_ReadInt PROTO((FILE *f));
  692. Nlm_Int4     Nlm_ReadLong PROTO((FILE *f));
  693. Nlm_FloatLo  Nlm_ReadReal PROTO((FILE *f));
  694. Nlm_FloatHi  Nlm_ReadDouble PROTO((FILE *f));
  695. void         Nlm_WriteChar PROTO((FILE *f, Nlm_Char ch));
  696. void         Nlm_WriteLn PROTO((FILE *f));
  697. void         Nlm_WriteString PROTO((FILE *f, Nlm_CharPtr str));
  698. void         Nlm_WriteCard PROTO((FILE *f, Nlm_Uint2 cardval, Nlm_Int2 length));
  699. void         Nlm_WriteInt PROTO((FILE *f, Nlm_Int2 intval, Nlm_Int2 length));
  700. void         Nlm_WriteLong PROTO((FILE *f, Nlm_Int4 longval, Nlm_Int2 length));
  701. void         Nlm_WriteReal PROTO((FILE *f, Nlm_FloatLo realval, Nlm_Int2 length, Nlm_Int2 dec));
  702. void         Nlm_WriteDouble PROTO((FILE *f, Nlm_FloatHi doubleval, Nlm_Int2 length, Nlm_Int2 dec));
  703.  
  704. /***  STRING HANDLING PROCEDURES  ***/
  705.  
  706. /*
  707. *  These string functions are intended to be both robust and portable
  708. *  across all operating systems that the NCBI toolbox will support.
  709. *  The maxsize parameter is usually passed sizeof (dest), and will
  710. *  prevent characters from being written past the allocated memory of
  711. *  a string.
  712. */
  713.  
  714. Nlm_Uint4    Nlm_StrngLen PROTO((Nlm_CharPtr string));
  715. void         Nlm_StrngCat PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, size_t maxsize));
  716. void         Nlm_StrngCpy PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, size_t maxsize));
  717. Nlm_Boolean  Nlm_StrngPos PROTO((Nlm_CharPtr str, Nlm_CharPtr sub, Nlm_Uint4 start, Nlm_Boolean caseCounts, Nlm_Uint4Ptr match));
  718. void         Nlm_StrngSeg PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_Uint4 start, Nlm_Uint4 length, size_t maxsize));
  719. void         Nlm_StrngRep PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_Uint4 start, size_t maxsize));
  720. Nlm_Boolean  Nlm_StrngEql PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  721. Nlm_Int2     Nlm_StrngCmp PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  722. Nlm_Int2     Nlm_SymblCmp PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  723.  
  724. /***  STRING TO NUMBER CONVERSION PROCEDURES  ***/
  725.  
  726. /*
  727. *  The boolean value returned by the String to Number functions indicates
  728. *  whether the conversion was successful (meaning that the string was in
  729. *  fact a legitimate number in the proper range).
  730. */
  731.  
  732. Nlm_Boolean  Nlm_StrToCard PROTO((Nlm_CharPtr str, Nlm_Uint2Ptr cardval));
  733. Nlm_Boolean  Nlm_StrToInt PROTO((Nlm_CharPtr str, Nlm_Int2Ptr intval));
  734. Nlm_Boolean  Nlm_StrToLong PROTO((Nlm_CharPtr str, Nlm_Int4Ptr longval));
  735. Nlm_Boolean  Nlm_StrToPtr PROTO((Nlm_CharPtr str, Nlm_VoidPtr PNTR ptrval));
  736. Nlm_Boolean  Nlm_StrToReal PROTO((Nlm_CharPtr str, Nlm_FloatLoPtr realval));
  737. Nlm_Boolean  Nlm_StrToDouble PROTO((Nlm_CharPtr str, Nlm_FloatHiPtr doubleval));
  738. void         Nlm_CardToStr PROTO((Nlm_Uint2 cardval, Nlm_CharPtr str, Nlm_Int2 length, size_t maxsize));
  739. void         Nlm_IntToStr PROTO((Nlm_Int2 intval, Nlm_CharPtr str, Nlm_Int2 length, size_t maxsize));
  740. void         Nlm_LongToStr PROTO((Nlm_Int4 longval, Nlm_CharPtr str, Nlm_Int2 length, size_t maxsize));
  741. void         Nlm_PtrToStr PROTO((Nlm_VoidPtr ptrval, Nlm_CharPtr str, Nlm_Int2 length, size_t maxsize));
  742. void         Nlm_RealToStr PROTO((Nlm_FloatLo realval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_Int2 dec, size_t maxsize));
  743. void         Nlm_DoubleToStr PROTO((Nlm_FloatHi doubleval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_Int2 dec, size_t maxsize));
  744.  
  745. /***  SPECIALIZED MEMORY ALLOCATION PROCEDURES  ***/
  746.  
  747. /*
  748. *  SetString and GetString are used to conveniently copy C strings to
  749. *  and from relocatable memory allocated on the heap.
  750. */
  751.  
  752. Nlm_Handle  Nlm_SetString PROTO((Nlm_Handle h, Nlm_CharPtr str));
  753. void        Nlm_GetString PROTO((Nlm_Handle h, Nlm_CharPtr str, size_t maxsize));
  754.  
  755. /***  MISCELLANEOUS PROCEDURES  ***/
  756.  
  757. //DUtil.h// void         Nlm_ArrowCursor PROTO((void));
  758. //DUtil.h// void         Nlm_CrossCursor PROTO((void));
  759. //DUtil.h// void         Nlm_IBeamCursor PROTO((void));
  760. //DUtil.h// void         Nlm_PlusCursor PROTO((void));
  761. //DUtil.h// void         Nlm_WatchCursor PROTO((void));
  762.  
  763. //DUtil.h// void         Nlm_Version PROTO((Nlm_CharPtr vsn, size_t maxsize));
  764.  
  765. //DUtil.h// void         Nlm_MousePosition PROTO((Nlm_PointPtr pt));
  766. //DUtil.h// Nlm_Boolean  Nlm_MouseButton PROTO((void));
  767. //DUtil.h// Nlm_Int4     Nlm_ComputerTime PROTO((void));
  768.  
  769. //DApplication.h//void         Nlm_ProgramPath PROTO((Nlm_CharPtr buf, size_t maxsize));
  770.  
  771. #ifdef WIN_MSWIN
  772. void         Nlm_DisableVibrant PROTO((void));
  773. void         Nlm_EnableVibrant PROTO((void));
  774. #endif /* WIN_MSWIN */
  775.  
  776. #ifdef __cplusplus
  777. }
  778. #endif
  779.  
  780. #endif
  781.